
export function removeTypeOneFromChildren(arr) {
    // 检查是否为数组，不是则直接返回
    if (!Array.isArray(arr)) {
        return arr;
    }

    // 处理数组中的每个元素
    return arr.map(item => {
        // 如果元素是对象且有children属性
        if (item && typeof item === 'object' && Array.isArray(item.children)) {
            // 递归处理children数组，过滤掉type等于1的对象
            const filteredChildren = item.children.filter(child => {
                // 只保留type不等于1的对象
                return !(child && typeof child === 'object' && child.type === 1);
            });

            // 对过滤后的children继续递归处理（处理更深层次的children）
            const processedChildren = removeTypeOneFromChildren(filteredChildren);

            // 返回新对象，避免修改原对象
            return {
                ...item,
                children: processedChildren
            };
        }
        // 如果元素是数组，递归处理
        else if (Array.isArray(item)) {
            return removeTypeOneFromChildren(item);
        }
        // 其他类型直接返回
        else {
            return item;
        }
    });
}

export function extractTypeOneFromChildren(arr) {
    // 用于存储提取到的对象
    const result = [];

    // 递归处理函数
    function processItem(item) {
        // 如果是数组，遍历每个元素
        if (Array.isArray(item)) {
            item.forEach(processItem);
        }
        // 如果是对象
        else if (item && typeof item === 'object') {
            // 检查是否有children数组
            if (Array.isArray(item.children)) {
                // 从children中筛选出type等于1的对象
                const typeOneItems = item.children.filter(child =>
                    child && typeof child === 'object' && child.type === 1
                );
                // 将找到的对象添加到结果数组
                result.push(...typeOneItems);

                // 递归处理children中的所有元素，查找更深层次的children
                item.children.forEach(processItem);
            }
        }
    }

    // 开始处理初始数组
    arr.forEach(processItem);

    return result;
}